home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / java / net / SocksSocketImpl.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  12.5 KB  |  885 lines
  1. package java.net;
  2.  
  3. import java.io.BufferedOutputStream;
  4. import java.io.IOException;
  5. import java.io.InputStream;
  6. import java.io.OutputStream;
  7. import java.io.UnsupportedEncodingException;
  8. import java.net.Proxy.Type;
  9. import java.security.AccessController;
  10. import java.security.PrivilegedActionException;
  11. import java.util.Iterator;
  12. import java.util.prefs.Preferences;
  13. import sun.net.www.ParseUtil;
  14. import sun.security.action.GetPropertyAction;
  15.  
  16. class SocksSocketImpl extends PlainSocketImpl implements SocksConsts {
  17.    private String server = null;
  18.    private int port = 1080;
  19.    private InetSocketAddress external_address;
  20.    private boolean useV4 = false;
  21.    private Socket cmdsock = null;
  22.    private InputStream cmdIn = null;
  23.    private OutputStream cmdOut = null;
  24.  
  25.    SocksSocketImpl() {
  26.    }
  27.  
  28.    SocksSocketImpl(String var1, int var2) {
  29.       this.server = var1;
  30.       this.port = var2 == -1 ? 1080 : var2;
  31.    }
  32.  
  33.    SocksSocketImpl(Proxy var1) {
  34.       SocketAddress var2 = var1.address();
  35.       if (var2 instanceof InetSocketAddress) {
  36.          InetSocketAddress var3 = (InetSocketAddress)var2;
  37.          this.server = var3.getHostString();
  38.          this.port = var3.getPort();
  39.       }
  40.  
  41.    }
  42.  
  43.    void setV4() {
  44.       this.useV4 = true;
  45.    }
  46.  
  47.    private synchronized void privilegedConnect(String var1, int var2, int var3) throws IOException {
  48.       try {
  49.          AccessController.doPrivileged(new 1(this, var1, var2, var3));
  50.       } catch (PrivilegedActionException var5) {
  51.          throw (IOException)var5.getException();
  52.       }
  53.    }
  54.  
  55.    private void superConnectServer(String var1, int var2, int var3) throws IOException {
  56.       super.connect(new InetSocketAddress(var1, var2), var3);
  57.    }
  58.  
  59.    private int readSocksReply(InputStream var1, byte[] var2) throws IOException {
  60.       int var3 = var2.length;
  61.       int var4 = 0;
  62.  
  63.       for(int var5 = 0; var4 < var3 && var5 < 3; ++var5) {
  64.          int var6 = var1.read(var2, var4, var3 - var4);
  65.          if (var6 < 0) {
  66.             throw new SocketException("Malformed reply from SOCKS server");
  67.          }
  68.  
  69.          var4 += var6;
  70.       }
  71.  
  72.       return var4;
  73.    }
  74.  
  75.    private boolean authenticate(byte var1, InputStream var2, BufferedOutputStream var3) throws IOException {
  76.       Object var4 = null;
  77.       if (var1 == 0) {
  78.          return true;
  79.       } else if (var1 == 2) {
  80.          String var7 = null;
  81.          InetAddress var8 = InetAddress.getByName(this.server);
  82.          PasswordAuthentication var9 = (PasswordAuthentication)AccessController.doPrivileged(new 2(this, var8));
  83.          String var6;
  84.          if (var9 != null) {
  85.             var6 = var9.getUserName();
  86.             var7 = new String(var9.getPassword());
  87.          } else {
  88.             Preferences var10 = Preferences.userRoot().node("/java/net/socks");
  89.  
  90.             try {
  91.                var6 = (String)AccessController.doPrivileged(new 3(this, var10));
  92.             } catch (PrivilegedActionException var13) {
  93.                throw (IOException)var13.getException();
  94.             }
  95.  
  96.             if (var6 != null) {
  97.                try {
  98.                   var7 = (String)AccessController.doPrivileged(new 4(this, var10));
  99.                } catch (PrivilegedActionException var12) {
  100.                   throw (IOException)var12.getException();
  101.                }
  102.             } else {
  103.                var6 = (String)AccessController.doPrivileged(new GetPropertyAction("user.name"));
  104.             }
  105.          }
  106.  
  107.          if (var6 == null) {
  108.             return false;
  109.          } else {
  110.             var3.write(1);
  111.             var3.write(var6.length());
  112.  
  113.             try {
  114.                var3.write(var6.getBytes("ISO-8859-1"));
  115.             } catch (UnsupportedEncodingException var15) {
  116.                assert false;
  117.             }
  118.  
  119.             if (var7 != null) {
  120.                var3.write(var7.length());
  121.  
  122.                try {
  123.                   var3.write(var7.getBytes("ISO-8859-1"));
  124.                } catch (UnsupportedEncodingException var14) {
  125.                   assert false;
  126.                }
  127.             } else {
  128.                var3.write(0);
  129.             }
  130.  
  131.             var3.flush();
  132.             byte[] var16 = new byte[2];
  133.             int var5 = this.readSocksReply(var2, var16);
  134.             if (var5 == 2 && var16[1] == 0) {
  135.                return true;
  136.             } else {
  137.                var3.close();
  138.                var2.close();
  139.                return false;
  140.             }
  141.          }
  142.       } else {
  143.          return false;
  144.       }
  145.    }
  146.  
  147.    private void connectV4(InputStream var1, OutputStream var2, InetSocketAddress var3) throws IOException {
  148.       if (!(var3.getAddress() instanceof Inet4Address)) {
  149.          throw new SocketException("SOCKS V4 requires IPv4 only addresses");
  150.       } else {
  151.          var2.write(4);
  152.          var2.write(1);
  153.          var2.write(var3.getPort() >> 8 & 255);
  154.          var2.write(var3.getPort() >> 0 & 255);
  155.          var2.write(var3.getAddress().getAddress());
  156.          String var4 = (String)AccessController.doPrivileged(new GetPropertyAction("user.name"));
  157.  
  158.          try {
  159.             var2.write(var4.getBytes("ISO-8859-1"));
  160.          } catch (UnsupportedEncodingException var8) {
  161.             assert false;
  162.          }
  163.  
  164.          var2.write(0);
  165.          var2.flush();
  166.          byte[] var5 = new byte[8];
  167.          int var6 = this.readSocksReply(var1, var5);
  168.          if (var6 != 8) {
  169.             throw new SocketException("Reply from SOCKS server has bad length: " + var6);
  170.          } else if (var5[0] != 0 && var5[0] != 4) {
  171.             throw new SocketException("Reply from SOCKS server has bad version");
  172.          } else {
  173.             SocketException var7 = null;
  174.             switch (var5[1]) {
  175.                case 90:
  176.                   this.external_address = var3;
  177.                   break;
  178.                case 91:
  179.                   var7 = new SocketException("SOCKS request rejected");
  180.                   break;
  181.                case 92:
  182.                   var7 = new SocketException("SOCKS server couldn't reach destination");
  183.                   break;
  184.                case 93:
  185.                   var7 = new SocketException("SOCKS authentication failed");
  186.                   break;
  187.                default:
  188.                   var7 = new SocketException("Reply from SOCKS server contains bad status");
  189.             }
  190.  
  191.             if (var7 != null) {
  192.                var1.close();
  193.                var2.close();
  194.                throw var7;
  195.             }
  196.          }
  197.       }
  198.    }
  199.  
  200.    protected void connect(SocketAddress var1, int var2) throws IOException {
  201.       SecurityManager var3 = System.getSecurityManager();
  202.       if (var1 != null && var1 instanceof InetSocketAddress) {
  203.          InetSocketAddress var4 = (InetSocketAddress)var1;
  204.          if (var3 != null) {
  205.             if (var4.isUnresolved()) {
  206.                var3.checkConnect(var4.getHostName(), var4.getPort());
  207.             } else {
  208.                var3.checkConnect(var4.getAddress().getHostAddress(), var4.getPort());
  209.             }
  210.          }
  211.  
  212.          if (this.server != null) {
  213.             try {
  214.                this.privilegedConnect(this.server, this.port, var2);
  215.             } catch (IOException var14) {
  216.                throw new SocketException(var14.getMessage());
  217.             }
  218.          } else {
  219.             ProxySelector var5 = (ProxySelector)AccessController.doPrivileged(new 5(this));
  220.             if (var5 == null) {
  221.                super.connect(var4, var2);
  222.                return;
  223.             }
  224.  
  225.             URI var6 = null;
  226.             String var7 = var4.getHostString();
  227.             if (var4.getAddress() instanceof Inet6Address && !var7.startsWith("[") && var7.indexOf(":") >= 0) {
  228.                var7 = "[" + var7 + "]";
  229.             }
  230.  
  231.             try {
  232.                var6 = new URI("socket://" + ParseUtil.encodePath(var7) + ":" + var4.getPort());
  233.             } catch (URISyntaxException var16) {
  234.                assert false : var16;
  235.             }
  236.  
  237.             Object var8 = null;
  238.             IOException var9 = null;
  239.             Object var10 = null;
  240.             Iterator var35 = var5.select(var6).iterator();
  241.             if (var35 == null || !var35.hasNext()) {
  242.                super.connect(var4, var2);
  243.                return;
  244.             }
  245.  
  246.             while(true) {
  247.                if (var35.hasNext()) {
  248.                   Proxy var25 = (Proxy)var35.next();
  249.                   if (var25 == null || var25 == Proxy.NO_PROXY) {
  250.                      super.connect(var4, var2);
  251.                      return;
  252.                   }
  253.  
  254.                   if (var25.type() != Type.SOCKS) {
  255.                      throw new SocketException("Unknown proxy type : " + var25.type());
  256.                   }
  257.  
  258.                   if (!(var25.address() instanceof InetSocketAddress)) {
  259.                      throw new SocketException("Unknow address type for proxy: " + var25);
  260.                   }
  261.  
  262.                   this.server = ((InetSocketAddress)var25.address()).getHostString();
  263.                   this.port = ((InetSocketAddress)var25.address()).getPort();
  264.  
  265.                   try {
  266.                      this.privilegedConnect(this.server, this.port, var2);
  267.                   } catch (IOException var17) {
  268.                      var5.connectFailed(var6, var25.address(), var17);
  269.                      this.server = null;
  270.                      this.port = -1;
  271.                      var9 = var17;
  272.                      continue;
  273.                   }
  274.                }
  275.  
  276.                if (this.server == null) {
  277.                   throw new SocketException("Can't connect to SOCKS proxy:" + var9.getMessage());
  278.                }
  279.                break;
  280.             }
  281.          }
  282.  
  283.          BufferedOutputStream var18 = new BufferedOutputStream(this.cmdOut, 512);
  284.          InputStream var19 = this.cmdIn;
  285.          if (this.useV4) {
  286.             if (var4.isUnresolved()) {
  287.                throw new UnknownHostException(var4.toString());
  288.             } else {
  289.                this.connectV4(var19, var18, var4);
  290.             }
  291.          } else {
  292.             var18.write(5);
  293.             var18.write(2);
  294.             var18.write(0);
  295.             var18.write(2);
  296.             var18.flush();
  297.             byte[] var20 = new byte[2];
  298.             int var26 = this.readSocksReply(var19, var20);
  299.             if (var26 == 2 && var20[0] == 5) {
  300.                if (var20[1] == -1) {
  301.                   throw new SocketException("SOCKS : No acceptable methods");
  302.                } else if (!this.authenticate(var20[1], var19, var18)) {
  303.                   throw new SocketException("SOCKS : authentication failed");
  304.                } else {
  305.                   var18.write(5);
  306.                   var18.write(1);
  307.                   var18.write(0);
  308.                   if (var4.isUnresolved()) {
  309.                      var18.write(3);
  310.                      var18.write(var4.getHostName().length());
  311.  
  312.                      try {
  313.                         var18.write(var4.getHostName().getBytes("ISO-8859-1"));
  314.                      } catch (UnsupportedEncodingException var15) {
  315.                         assert false;
  316.                      }
  317.  
  318.                      var18.write(var4.getPort() >> 8 & 255);
  319.                      var18.write(var4.getPort() >> 0 & 255);
  320.                   } else if (var4.getAddress() instanceof Inet6Address) {
  321.                      var18.write(4);
  322.                      var18.write(var4.getAddress().getAddress());
  323.                      var18.write(var4.getPort() >> 8 & 255);
  324.                      var18.write(var4.getPort() >> 0 & 255);
  325.                   } else {
  326.                      var18.write(1);
  327.                      var18.write(var4.getAddress().getAddress());
  328.                      var18.write(var4.getPort() >> 8 & 255);
  329.                      var18.write(var4.getPort() >> 0 & 255);
  330.                   }
  331.  
  332.                   var18.flush();
  333.                   var20 = new byte[4];
  334.                   var26 = this.readSocksReply(var19, var20);
  335.                   if (var26 != 4) {
  336.                      throw new SocketException("Reply from SOCKS server has bad length");
  337.                   } else {
  338.                      SocketException var34;
  339.                      var34 = null;
  340.                      label120:
  341.                      switch (var20[1]) {
  342.                         case 0:
  343.                            switch (var20[3]) {
  344.                               case 1:
  345.                                  byte[] var40 = new byte[4];
  346.                                  var26 = this.readSocksReply(var19, var40);
  347.                                  if (var26 != 4) {
  348.                                     throw new SocketException("Reply from SOCKS server badly formatted");
  349.                                  }
  350.  
  351.                                  var20 = new byte[2];
  352.                                  var26 = this.readSocksReply(var19, var20);
  353.                                  if (var26 != 2) {
  354.                                     throw new SocketException("Reply from SOCKS server badly formatted");
  355.                                  }
  356.  
  357.                                  int var38 = (var20[0] & 255) << 8;
  358.                                  int var42 = var38 + (var20[1] & 255);
  359.                                  break label120;
  360.                               case 2:
  361.                               default:
  362.                                  var34 = new SocketException("Reply from SOCKS server contains wrong code");
  363.                                  break label120;
  364.                               case 3:
  365.                                  byte var39 = var20[1];
  366.                                  byte[] var13 = new byte[var39];
  367.                                  var26 = this.readSocksReply(var19, var13);
  368.                                  if (var26 != var39) {
  369.                                     throw new SocketException("Reply from SOCKS server badly formatted");
  370.                                  }
  371.  
  372.                                  var20 = new byte[2];
  373.                                  var26 = this.readSocksReply(var19, var20);
  374.                                  if (var26 != 2) {
  375.                                     throw new SocketException("Reply from SOCKS server badly formatted");
  376.                                  }
  377.  
  378.                                  int var37 = (var20[0] & 255) << 8;
  379.                                  int var41 = var37 + (var20[1] & 255);
  380.                                  break label120;
  381.                               case 4:
  382.                                  byte var11 = var20[1];
  383.                                  byte[] var12 = new byte[var11];
  384.                                  var26 = this.readSocksReply(var19, var12);
  385.                                  if (var26 != var11) {
  386.                                     throw new SocketException("Reply from SOCKS server badly formatted");
  387.                                  }
  388.  
  389.                                  var20 = new byte[2];
  390.                                  var26 = this.readSocksReply(var19, var20);
  391.                                  if (var26 != 2) {
  392.                                     throw new SocketException("Reply from SOCKS server badly formatted");
  393.                                  }
  394.  
  395.                                  int var36 = (var20[0] & 255) << 8;
  396.                                  int var10000 = var36 + (var20[1] & 255);
  397.                                  break label120;
  398.                            }
  399.                         case 1:
  400.                            var34 = new SocketException("SOCKS server general failure");
  401.                            break;
  402.                         case 2:
  403.                            var34 = new SocketException("SOCKS: Connection not allowed by ruleset");
  404.                            break;
  405.                         case 3:
  406.                            var34 = new SocketException("SOCKS: Network unreachable");
  407.                            break;
  408.                         case 4:
  409.                            var34 = new SocketException("SOCKS: Host unreachable");
  410.                            break;
  411.                         case 5:
  412.                            var34 = new SocketException("SOCKS: Connection refused");
  413.                            break;
  414.                         case 6:
  415.                            var34 = new SocketException("SOCKS: TTL expired");
  416.                            break;
  417.                         case 7:
  418.                            var34 = new SocketException("SOCKS: Command not supported");
  419.                            break;
  420.                         case 8:
  421.                            var34 = new SocketException("SOCKS: address type not supported");
  422.                      }
  423.  
  424.                      if (var34 != null) {
  425.                         var19.close();
  426.                         var18.close();
  427.                         throw var34;
  428.                      } else {
  429.                         this.external_address = var4;
  430.                      }
  431.                   }
  432.                }
  433.             } else if (var4.isUnresolved()) {
  434.                throw new UnknownHostException(var4.toString());
  435.             } else {
  436.                this.connectV4(var19, var18, var4);
  437.             }
  438.          }
  439.       } else {
  440.          throw new IllegalArgumentException("Unsupported address type");
  441.       }
  442.    }
  443.  
  444.    private void bindV4(InputStream var1, OutputStream var2, InetAddress var3, int var4) throws IOException {
  445.       if (!(var3 instanceof Inet4Address)) {
  446.          throw new SocketException("SOCKS V4 requires IPv4 only addresses");
  447.       } else {
  448.          super.bind(var3, var4);
  449.          byte[] var5 = var3.getAddress();
  450.          if (var3.isAnyLocalAddress()) {
  451.             InetAddress var6 = this.cmdsock.getLocalAddress();
  452.             var5 = var6.getAddress();
  453.          }
  454.  
  455.          var2.write(4);
  456.          var2.write(2);
  457.          var2.write(super.getLocalPort() >> 8 & 255);
  458.          var2.write(super.getLocalPort() >> 0 & 255);
  459.          var2.write(var5);
  460.          String var7 = (String)AccessController.doPrivileged(new GetPropertyAction("user.name"));
  461.  
  462.          try {
  463.             var2.write(var7.getBytes("ISO-8859-1"));
  464.          } catch (UnsupportedEncodingException var11) {
  465.             assert false;
  466.          }
  467.  
  468.          var2.write(0);
  469.          var2.flush();
  470.          byte[] var8 = new byte[8];
  471.          int var9 = this.readSocksReply(var1, var8);
  472.          if (var9 != 8) {
  473.             throw new SocketException("Reply from SOCKS server has bad length: " + var9);
  474.          } else if (var8[0] != 0 && var8[0] != 4) {
  475.             throw new SocketException("Reply from SOCKS server has bad version");
  476.          } else {
  477.             SocketException var10 = null;
  478.             switch (var8[1]) {
  479.                case 90:
  480.                   this.external_address = new InetSocketAddress(var3, var4);
  481.                   break;
  482.                case 91:
  483.                   var10 = new SocketException("SOCKS request rejected");
  484.                   break;
  485.                case 92:
  486.                   var10 = new SocketException("SOCKS server couldn't reach destination");
  487.                   break;
  488.                case 93:
  489.                   var10 = new SocketException("SOCKS authentication failed");
  490.                   break;
  491.                default:
  492.                   var10 = new SocketException("Reply from SOCKS server contains bad status");
  493.             }
  494.  
  495.             if (var10 != null) {
  496.                var1.close();
  497.                var2.close();
  498.                throw var10;
  499.             }
  500.          }
  501.       }
  502.    }
  503.  
  504.    protected synchronized void socksBind(InetSocketAddress var1) throws IOException {
  505.       if (this.socket == null) {
  506.          if (this.server != null) {
  507.             try {
  508.                AccessController.doPrivileged(new 8(this));
  509.             } catch (Exception var13) {
  510.                throw new SocketException(var13.getMessage());
  511.             }
  512.          } else {
  513.             ProxySelector var2 = (ProxySelector)AccessController.doPrivileged(new 6(this));
  514.             if (var2 == null) {
  515.                return;
  516.             }
  517.  
  518.             URI var3 = null;
  519.             String var4 = var1.getHostString();
  520.             if (var1.getAddress() instanceof Inet6Address && !var4.startsWith("[") && var4.indexOf(":") >= 0) {
  521.                var4 = "[" + var4 + "]";
  522.             }
  523.  
  524.             try {
  525.                var3 = new URI("serversocket://" + ParseUtil.encodePath(var4) + ":" + var1.getPort());
  526.             } catch (URISyntaxException var16) {
  527.                assert false : var16;
  528.             }
  529.  
  530.             Object var5 = null;
  531.             Exception var6 = null;
  532.             Object var7 = null;
  533.             Iterator var33 = var2.select(var3).iterator();
  534.             if (var33 == null || !var33.hasNext()) {
  535.                return;
  536.             }
  537.  
  538.             while(var33.hasNext()) {
  539.                Proxy var24 = (Proxy)var33.next();
  540.                if (var24 == null || var24 == Proxy.NO_PROXY) {
  541.                   return;
  542.                }
  543.  
  544.                if (var24.type() != Type.SOCKS) {
  545.                   throw new SocketException("Unknown proxy type : " + var24.type());
  546.                }
  547.  
  548.                if (!(var24.address() instanceof InetSocketAddress)) {
  549.                   throw new SocketException("Unknow address type for proxy: " + var24);
  550.                }
  551.  
  552.                this.server = ((InetSocketAddress)var24.address()).getHostString();
  553.                this.port = ((InetSocketAddress)var24.address()).getPort();
  554.  
  555.                try {
  556.                   AccessController.doPrivileged(new 7(this));
  557.                } catch (Exception var14) {
  558.                   var2.connectFailed(var3, var24.address(), new SocketException(var14.getMessage()));
  559.                   this.server = null;
  560.                   this.port = -1;
  561.                   this.cmdsock = null;
  562.                   var6 = var14;
  563.                }
  564.             }
  565.  
  566.             if (this.server == null || this.cmdsock == null) {
  567.                throw new SocketException("Can't connect to SOCKS proxy:" + var6.getMessage());
  568.             }
  569.          }
  570.  
  571.          BufferedOutputStream var17 = new BufferedOutputStream(this.cmdOut, 512);
  572.          InputStream var18 = this.cmdIn;
  573.          if (this.useV4) {
  574.             this.bindV4(var18, var17, var1.getAddress(), var1.getPort());
  575.          } else {
  576.             var17.write(5);
  577.             var17.write(2);
  578.             var17.write(0);
  579.             var17.write(2);
  580.             var17.flush();
  581.             byte[] var19 = new byte[2];
  582.             int var25 = this.readSocksReply(var18, var19);
  583.             if (var25 == 2 && var19[0] == 5) {
  584.                if (var19[1] == -1) {
  585.                   throw new SocketException("SOCKS : No acceptable methods");
  586.                } else if (!this.authenticate(var19[1], var18, var17)) {
  587.                   throw new SocketException("SOCKS : authentication failed");
  588.                } else {
  589.                   var17.write(5);
  590.                   var17.write(2);
  591.                   var17.write(0);
  592.                   int var32 = var1.getPort();
  593.                   if (var1.isUnresolved()) {
  594.                      var17.write(3);
  595.                      var17.write(var1.getHostName().length());
  596.  
  597.                      try {
  598.                         var17.write(var1.getHostName().getBytes("ISO-8859-1"));
  599.                      } catch (UnsupportedEncodingException var15) {
  600.                         assert false;
  601.                      }
  602.  
  603.                      var17.write(var32 >> 8 & 255);
  604.                      var17.write(var32 >> 0 & 255);
  605.                   } else if (var1.getAddress() instanceof Inet4Address) {
  606.                      byte[] var34 = var1.getAddress().getAddress();
  607.                      var17.write(1);
  608.                      var17.write(var34);
  609.                      var17.write(var32 >> 8 & 255);
  610.                      var17.write(var32 >> 0 & 255);
  611.                      var17.flush();
  612.                   } else {
  613.                      if (!(var1.getAddress() instanceof Inet6Address)) {
  614.                         this.cmdsock.close();
  615.                         throw new SocketException("unsupported address type : " + var1);
  616.                      }
  617.  
  618.                      byte[] var35 = var1.getAddress().getAddress();
  619.                      var17.write(4);
  620.                      var17.write(var35);
  621.                      var17.write(var32 >> 8 & 255);
  622.                      var17.write(var32 >> 0 & 255);
  623.                      var17.flush();
  624.                   }
  625.  
  626.                   SocketException var36;
  627.                   var19 = new byte[4];
  628.                   this.readSocksReply(var18, var19);
  629.                   var36 = null;
  630.                   label111:
  631.                   switch (var19[1]) {
  632.                      case 0:
  633.                         Object var11 = null;
  634.                         switch (var19[3]) {
  635.                            case 1:
  636.                               byte[] var43 = new byte[4];
  637.                               var25 = this.readSocksReply(var18, var43);
  638.                               if (var25 != 4) {
  639.                                  throw new SocketException("Reply from SOCKS server badly formatted");
  640.                               }
  641.  
  642.                               var19 = new byte[2];
  643.                               var25 = this.readSocksReply(var18, var19);
  644.                               if (var25 != 2) {
  645.                                  throw new SocketException("Reply from SOCKS server badly formatted");
  646.                               }
  647.  
  648.                               int var41 = (var19[0] & 255) << 8;
  649.                               var41 += var19[1] & 255;
  650.                               this.external_address = new InetSocketAddress(new Inet4Address("", var43), var41);
  651.                            case 2:
  652.                            default:
  653.                               break label111;
  654.                            case 3:
  655.                               byte var37 = var19[1];
  656.                               byte[] var12 = new byte[var37];
  657.                               var25 = this.readSocksReply(var18, var12);
  658.                               if (var25 != var37) {
  659.                                  throw new SocketException("Reply from SOCKS server badly formatted");
  660.                               }
  661.  
  662.                               var19 = new byte[2];
  663.                               var25 = this.readSocksReply(var18, var19);
  664.                               if (var25 != 2) {
  665.                                  throw new SocketException("Reply from SOCKS server badly formatted");
  666.                               }
  667.  
  668.                               int var39 = (var19[0] & 255) << 8;
  669.                               var39 += var19[1] & 255;
  670.                               this.external_address = new InetSocketAddress(new String(var12), var39);
  671.                               break label111;
  672.                            case 4:
  673.                               byte var8 = var19[1];
  674.                               byte[] var10 = new byte[var8];
  675.                               var25 = this.readSocksReply(var18, var10);
  676.                               if (var25 != var8) {
  677.                                  throw new SocketException("Reply from SOCKS server badly formatted");
  678.                               }
  679.  
  680.                               var19 = new byte[2];
  681.                               var25 = this.readSocksReply(var18, var19);
  682.                               if (var25 != 2) {
  683.                                  throw new SocketException("Reply from SOCKS server badly formatted");
  684.                               }
  685.  
  686.                               int var9 = (var19[0] & 255) << 8;
  687.                               var9 += var19[1] & 255;
  688.                               this.external_address = new InetSocketAddress(new Inet6Address("", var10), var9);
  689.                               break label111;
  690.                         }
  691.                      case 1:
  692.                         var36 = new SocketException("SOCKS server general failure");
  693.                         break;
  694.                      case 2:
  695.                         var36 = new SocketException("SOCKS: Bind not allowed by ruleset");
  696.                         break;
  697.                      case 3:
  698.                         var36 = new SocketException("SOCKS: Network unreachable");
  699.                         break;
  700.                      case 4:
  701.                         var36 = new SocketException("SOCKS: Host unreachable");
  702.                         break;
  703.                      case 5:
  704.                         var36 = new SocketException("SOCKS: Connection refused");
  705.                         break;
  706.                      case 6:
  707.                         var36 = new SocketException("SOCKS: TTL expired");
  708.                         break;
  709.                      case 7:
  710.                         var36 = new SocketException("SOCKS: Command not supported");
  711.                         break;
  712.                      case 8:
  713.                         var36 = new SocketException("SOCKS: address type not supported");
  714.                   }
  715.  
  716.                   if (var36 != null) {
  717.                      var18.close();
  718.                      var17.close();
  719.                      this.cmdsock.close();
  720.                      this.cmdsock = null;
  721.                      throw var36;
  722.                   } else {
  723.                      this.cmdIn = var18;
  724.                      this.cmdOut = var17;
  725.                   }
  726.                }
  727.             } else {
  728.                this.bindV4(var18, var17, var1.getAddress(), var1.getPort());
  729.             }
  730.          }
  731.       }
  732.    }
  733.  
  734.    protected void acceptFrom(SocketImpl var1, InetSocketAddress var2) throws IOException {
  735.       if (this.cmdsock != null) {
  736.          InputStream var3;
  737.          SocketException var5;
  738.          InetSocketAddress var8;
  739.          var3 = this.cmdIn;
  740.          this.socksBind(var2);
  741.          var3.read();
  742.          int var4 = var3.read();
  743.          var3.read();
  744.          var5 = null;
  745.          var8 = null;
  746.          label36:
  747.          switch (var4) {
  748.             case 0:
  749.                var4 = var3.read();
  750.                switch (var4) {
  751.                   case 1:
  752.                      byte[] var17 = new byte[4];
  753.                      this.readSocksReply(var3, var17);
  754.                      int var14 = var3.read() << 8;
  755.                      var14 += var3.read();
  756.                      var8 = new InetSocketAddress(new Inet4Address("", var17), var14);
  757.                   case 2:
  758.                   default:
  759.                      break label36;
  760.                   case 3:
  761.                      int var9 = var3.read();
  762.                      byte[] var16 = new byte[var9];
  763.                      this.readSocksReply(var3, var16);
  764.                      int var12 = var3.read() << 8;
  765.                      var12 += var3.read();
  766.                      var8 = new InetSocketAddress(new String(var16), var12);
  767.                      break label36;
  768.                   case 4:
  769.                      byte[] var7 = new byte[16];
  770.                      this.readSocksReply(var3, var7);
  771.                      int var6 = var3.read() << 8;
  772.                      var6 += var3.read();
  773.                      var8 = new InetSocketAddress(new Inet6Address("", var7), var6);
  774.                      break label36;
  775.                }
  776.             case 1:
  777.                var5 = new SocketException("SOCKS server general failure");
  778.                break;
  779.             case 2:
  780.                var5 = new SocketException("SOCKS: Accept not allowed by ruleset");
  781.                break;
  782.             case 3:
  783.                var5 = new SocketException("SOCKS: Network unreachable");
  784.                break;
  785.             case 4:
  786.                var5 = new SocketException("SOCKS: Host unreachable");
  787.                break;
  788.             case 5:
  789.                var5 = new SocketException("SOCKS: Connection refused");
  790.                break;
  791.             case 6:
  792.                var5 = new SocketException("SOCKS: TTL expired");
  793.                break;
  794.             case 7:
  795.                var5 = new SocketException("SOCKS: Command not supported");
  796.                break;
  797.             case 8:
  798.                var5 = new SocketException("SOCKS: address type not supported");
  799.          }
  800.  
  801.          if (var5 != null) {
  802.             this.cmdIn.close();
  803.             this.cmdOut.close();
  804.             this.cmdsock.close();
  805.             this.cmdsock = null;
  806.             throw var5;
  807.          } else {
  808.             if (var1 instanceof SocksSocketImpl) {
  809.                ((SocksSocketImpl)var1).external_address = var8;
  810.             }
  811.  
  812.             if (var1 instanceof PlainSocketImpl) {
  813.                ((PlainSocketImpl)var1).setInputStream((SocketInputStream)var3);
  814.             }
  815.  
  816.             var1.fd = this.cmdsock.getImpl().fd;
  817.             var1.address = this.cmdsock.getImpl().address;
  818.             var1.port = this.cmdsock.getImpl().port;
  819.             var1.localport = this.cmdsock.getImpl().localport;
  820.             this.cmdsock = null;
  821.          }
  822.       }
  823.    }
  824.  
  825.    protected InetAddress getInetAddress() {
  826.       return this.external_address != null ? this.external_address.getAddress() : super.getInetAddress();
  827.    }
  828.  
  829.    protected int getPort() {
  830.       return this.external_address != null ? this.external_address.getPort() : super.getPort();
  831.    }
  832.  
  833.    protected int getLocalPort() {
  834.       if (this.socket != null) {
  835.          return super.getLocalPort();
  836.       } else {
  837.          return this.external_address != null ? this.external_address.getPort() : super.getLocalPort();
  838.       }
  839.    }
  840.  
  841.    protected void close() throws IOException {
  842.       if (this.cmdsock != null) {
  843.          this.cmdsock.close();
  844.       }
  845.  
  846.       this.cmdsock = null;
  847.       super.close();
  848.    }
  849.  
  850.    // $FF: synthetic method
  851.    static void access$000(SocksSocketImpl var0, String var1, int var2, int var3) throws IOException {
  852.       var0.superConnectServer(var1, var2, var3);
  853.    }
  854.  
  855.    // $FF: synthetic method
  856.    static InputStream access$102(SocksSocketImpl var0, InputStream var1) {
  857.       return var0.cmdIn = var1;
  858.    }
  859.  
  860.    // $FF: synthetic method
  861.    static OutputStream access$202(SocksSocketImpl var0, OutputStream var1) {
  862.       return var0.cmdOut = var1;
  863.    }
  864.  
  865.    // $FF: synthetic method
  866.    static String access$300(SocksSocketImpl var0) {
  867.       return var0.server;
  868.    }
  869.  
  870.    // $FF: synthetic method
  871.    static int access$400(SocksSocketImpl var0) {
  872.       return var0.port;
  873.    }
  874.  
  875.    // $FF: synthetic method
  876.    static Socket access$502(SocksSocketImpl var0, Socket var1) {
  877.       return var0.cmdsock = var1;
  878.    }
  879.  
  880.    // $FF: synthetic method
  881.    static Socket access$500(SocksSocketImpl var0) {
  882.       return var0.cmdsock;
  883.    }
  884. }
  885.